// Copyright 2004-2010 Castle Project - http://www.castleproject.org/
// 
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// 
//     http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.


namespace Fas.Tem.Runtime.Parser
{
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Text;

    /* Generated By:JJTree&JavaCC: Do not edit this line. ParserTokenManager.java */

    public class ParserTokenManager : ParserConstants
    {
        private int lparen = 0;
        private int rparen = 0;

        private readonly Stack<Dictionary<string, int>> stateStack = new Stack<Dictionary<string, int>>();
        public bool debugPrint = false;

        public bool inDirective;
        private bool inComment;
        public bool inSet;

        /**
	 *  pushes the current state onto the 'state stack',
	 *  and maintains the parens counts
	 *  public because we need it in PD &amp; VM handling
	 *
	 *  @return bool : success.  It can fail if the state machine
	 *     gets messed up (do don't mess it up :)
	 */

        public bool StateStackPop()
        {
            Dictionary<string, int> h;

            try
            {
                h = stateStack.Pop();
            }
            // was EmptyStackException
            catch (InvalidOperationException)
            {
                lparen = 0;
                SwitchTo(DEFAULT);
                return false;
            }

            if (debugPrint)
            {
                Console.Out.WriteLine(" stack pop ({0}) : lparen={1} newstate={2}", stateStack.Count, h["lparen"],
                                      h["lexstate"]);
            }

            lparen = h["lparen"];
            rparen = h["rparen"];

            SwitchTo(h["lexstate"]);

            return true;
        }

        /**
	 *  pops a state off the stack, and restores paren counts
	 *
	 *  @return bool : success of operation
	 */

        public bool StateStackPush()
        {
            if (debugPrint)
            {
                Console.Out.WriteLine(" ({0}) pushing cur state : {1}", stateStack.Count, curLexState);
            }

            Dictionary<string, int> h = new Dictionary<string, int>
            {
                { "lexstate", curLexState },
                { "lparen", lparen },
                { "rparen", rparen }
            };

            lparen = 0;

            stateStack.Push(h);

            return true;
        }

        /**
	 *  Clears all state variables, resets to
	 *  start values, clears stateStack.  Call
	 *  before parsing.
	 *  @return void
	 */

        public void ClearStateVars()
        {
            stateStack.Clear();

            lparen = 0;
            rparen = 0;
            inDirective = false;
            inComment = false;
            inSet = false;

            return;
        }


        /**
	 *  handles the dropdown logic when encountering a RPAREN
	 */

        private void RPARENHandler()
        {
            /*
	     *  Ultimately, we want to drop down to the state below 
	     *  the one that has an open (if we hit bottom (DEFAULT), 
	     *  that's fine. It's just text schmoo.
	     */

            bool closed = false;

            if (inComment)
            {
                closed = true;
            }

            while (!closed)
            {
                /*
		 * look at current state.  If we haven't seen a lparen 
		 * in this state then we drop a state, because this 
		 * lparen clearly closes our state
		 */

                if (lparen > 0)
                {
                    /*
		     *  if rparen + 1 == lparen, then this state is closed. 
		     * Otherwise, increment and keep parsing
		     */

                    if (lparen == rparen + 1)
                    {
                        StateStackPop();
                    }
                    else
                    {
                        rparen++;
                    }

                    closed = true;
                }
                else
                {
                    /*
		     * now, drop a state
		     */

                    if (!StateStackPop())
                    {
                        break;
                    }
                }
            }
        }

        public TextWriter debugStream = Console.Out;

        public void SetDebugStream(StreamWriter ds)
        {
            debugStream = ds;
        }

        private int jjStopStringLiteralDfa_0(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0x6000000L) != 0L)
                    {
                        jjmatchedKind = 52;
                        return 33;
                    }
                    if ((active0 & 0x10000000L) != 0L)
                    {
                        return 31;
                    }

                    if ((active0 & 0xd000L) != 0L)
                    {
                        return 7;
                    }

                    return -1;
                case 1:
                    if ((active0 & 0x6000000L) != 0L)
                    {
                        jjmatchedKind = 52;
                        jjmatchedPos = 1;
                        return 33;
                    }
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return 5;
                    }

                    return -1;
                case 2:
                    if ((active0 & 0x6000000L) != 0L)
                    {
                        jjmatchedKind = 52;
                        jjmatchedPos = 2;
                        return 33;
                    }
                    return -1;
                case 3:
                    if ((active0 & 0x4000000L) != 0L)
                    {
                        jjmatchedKind = 52;
                        jjmatchedPos = 3;
                        return 33;
                    }
                    if ((active0 & 0x2000000L) != 0L)
                    {
                        return 33;
                    }

                    return -1;
                default:
                    return -1;
            }
        }

        private int jjStartNfa_0(int pos, long active0)
        {
            return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
        }

        private int jjStopAtPos(int pos, int kind)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            return pos + 1;
        }

        private int jjStartNfaWithStates_0(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            if (!input_stream.ReadChar())
            {
                return pos + 1;
            }
            return jjMoveNfa_0(state, pos + 1);
        }

        private int jjMoveStringLiteralDfa0_0()
        {
            switch (input_stream.CurrentCharacter)
            {
                case (char)33:
                    jjmatchedKind = 41;
                    return jjMoveStringLiteralDfa1_0(0x10000000000L);
                case (char)35:
                    jjmatchedKind = 15;
                    return jjMoveStringLiteralDfa1_0(0x5000L);
                case (char)37:
                    return jjStopAtPos(0, 32);
                case (char)38:
                    return jjMoveStringLiteralDfa1_0(0x200000000L);
                case (char)40:
                    return jjStopAtPos(0, 5);
                case (char)42:
                    return jjStopAtPos(0, 30);
                case (char)43:
                    return jjStopAtPos(0, 29);
                case (char)44:
                    return jjStopAtPos(0, 3);
                case (char)45:
                    return jjStartNfaWithStates_0(0, 28, 31);
                case (char)46:
                    return jjMoveStringLiteralDfa1_0(0x10L);
                case (char)47:
                    return jjStopAtPos(0, 31);
                case (char)60:
                    jjmatchedKind = 35;
                    return jjMoveStringLiteralDfa1_0(0x1000000000L);
                case (char)61:
                    jjmatchedKind = 42;
                    return jjMoveStringLiteralDfa1_0(0x8000000000L);
                case (char)62:
                    jjmatchedKind = 37;
                    return jjMoveStringLiteralDfa1_0(0x4000000000L);
                case (char)91:
                    return jjStopAtPos(0, 1);
                case (char)93:
                    return jjStopAtPos(0, 2);
                case (char)102:
                    return jjMoveStringLiteralDfa1_0(0x4000000L);
                case (char)116:
                    return jjMoveStringLiteralDfa1_0(0x2000000L);
                case (char)124:
                    return jjMoveStringLiteralDfa1_0(0x400000000L);
                default:
                    return jjMoveNfa_0(0, 0);
            }
        }

        private int jjMoveStringLiteralDfa1_0(long active0)
        {
            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_0(0, active0);
                return 1;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    if ((active0 & 0x1000L) != 0L)
                    {
                        return jjStopAtPos(1, 12);
                    }

                    break;
                case (char)38:
                    if ((active0 & 0x200000000L) != 0L)
                    {
                        return jjStopAtPos(1, 33);
                    }

                    break;
                case (char)42:
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return jjStartNfaWithStates_0(1, 14, 5);
                    }

                    break;
                case (char)46:
                    if ((active0 & 0x10L) != 0L)
                    {
                        return jjStopAtPos(1, 4);
                    }

                    break;
                case (char)61:
                    if ((active0 & 0x1000000000L) != 0L)
                    {
                        return jjStopAtPos(1, 36);
                    }
                    else if ((active0 & 0x4000000000L) != 0L)
                    {
                        return jjStopAtPos(1, 38);
                    }
                    else if ((active0 & 0x8000000000L) != 0L)
                    {
                        return jjStopAtPos(1, 39);
                    }
                    else if ((active0 & 0x10000000000L) != 0L)
                    {
                        return jjStopAtPos(1, 40);
                    }

                    break;
                case (char)97:
                    return jjMoveStringLiteralDfa2_0(active0, 0x4000000L);
                case (char)114:
                    return jjMoveStringLiteralDfa2_0(active0, 0x2000000L);
                case (char)124:
                    if ((active0 & 0x400000000L) != 0L)
                    {
                        return jjStopAtPos(1, 34);
                    }

                    break;
                default:
                    break;
            }
            return jjStartNfa_0(0, active0);
        }

        private int jjMoveStringLiteralDfa2_0(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_0(0, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_0(1, active0);
                return 2;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)108:
                    return jjMoveStringLiteralDfa3_0(active0, 0x4000000L);
                case (char)117:
                    return jjMoveStringLiteralDfa3_0(active0, 0x2000000L);
                default:
                    break;
            }
            return jjStartNfa_0(1, active0);
        }

        private int jjMoveStringLiteralDfa3_0(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_0(1, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_0(2, active0);
                return 3;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)101:
                    if ((active0 & 0x2000000L) != 0L)
                    {
                        return jjStartNfaWithStates_0(3, 25, 33);
                    }

                    break;
                case (char)115:
                    return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);
                default:
                    break;
            }
            return jjStartNfa_0(2, active0);
        }

        private int jjMoveStringLiteralDfa4_0(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_0(2, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_0(3, active0);
                return 4;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)101:
                    if ((active0 & 0x4000000L) != 0L)
                    {
                        return jjStartNfaWithStates_0(4, 26, 33);
                    }

                    break;
                default:
                    break;
            }
            return jjStartNfa_0(3, active0);
        }

        private void jjCheckNAdd(int state)
        {
            if (jjrounds[state] != jjround)
            {
                jjstateSet[jjnewStateCnt++] = (uint)state;
                jjrounds[state] = jjround;
            }
        }

        private void jjAddStates(int start, int end)
        {
            do
            {
                jjstateSet[jjnewStateCnt++] = (uint)jjnextStates[start];
            } while (start++ != end);
        }

        private void jjCheckNAddTwoStates(int state1, int state2)
        {
            jjCheckNAdd(state1);
            jjCheckNAdd(state2);
        }

        private void jjCheckNAddStates(int start, int end)
        {
            do
            {
                jjCheckNAdd(jjnextStates[start]);
            } while (start++ != end);
        }


        private static readonly ulong[] jjbitVec0 = {
                                               0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
                                           };

        private static readonly ulong[] jjbitVec2 = {
                                               0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
                                           };

        private int jjMoveNfa_0(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 42;
            int i = 1;
            jjstateSet[0] = (uint)startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                {
                    ReInitRounds();
                }

                char character = input_stream.CurrentCharacter;
                if (character < 64)
                {
                    long l = 1L << character;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 0:
                                if ((0x3ff000000000000L & l) != 0L)
                                {
                                    if (kind > 49)
                                    {
                                        kind = 49;
                                    }

                                    jjCheckNAdd(31);
                                }
                                else if ((0x2400L & l) != 0L)
                                {
                                    if (kind > 27)
                                    {
                                        kind = 27;
                                    }
                                }
                                else if ((0x100000200L & l) != 0L)
                                {
                                    if (kind > 23)
                                    {
                                        kind = 23;
                                    }

                                    jjCheckNAdd(9);
                                }
                                else if (character == 36)
                                {
                                    if (kind > 10)
                                    {
                                        kind = 10;
                                    }

                                    jjCheckNAddTwoStates(39, 40);
                                }
                                else if (character == 45)
                                {
                                    jjCheckNAdd(31);
                                }
                                else if (character == 39)
                                {
                                    jjCheckNAddStates(0, 2);
                                }
                                else if (character == 34)
                                {
                                    jjCheckNAddStates(3, 5);
                                }
                                else if (character == 35)
                                {
                                    jjstateSet[jjnewStateCnt++] = 7;
                                }
                                else if (character == 41)
                                {
                                    if (kind > 6)
                                    {
                                        kind = 6;
                                    }

                                    jjCheckNAddStates(6, 8);
                                }
                                if (character == 13)
                                {
                                    jjstateSet[jjnewStateCnt++] = 28;
                                }

                                break;
                            case 1:
                                if ((0x100000200L & l) != 0L)
                                {
                                    jjCheckNAddStates(6, 8);
                                }

                                break;
                            case 2:
                                if ((0x2400L & l) != 0L && kind > 6)
                                {
                                    kind = 6;
                                }

                                break;
                            case 3:
                                if (character == 10 && kind > 6)
                                {
                                    kind = 6;
                                }

                                break;
                            case 4:
                                if (character == 13)
                                {
                                    jjstateSet[jjnewStateCnt++] = 3;
                                }

                                break;
                            case 5:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 6;
                                }

                                break;
                            case 6:
                                if ((0xfffffff7ffffffffUL & (ulong)l) != 0L && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 7:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 5;
                                }

                                break;
                            case 8:
                                if (character == 35)
                                {
                                    jjstateSet[jjnewStateCnt++] = 7;
                                }

                                break;
                            case 9:
                                if ((0x100000200L & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 23)
                                {
                                    kind = 23;
                                }

                                jjCheckNAdd(9);
                                break;
                            case 10:
                                if (character == 34)
                                {
                                    jjCheckNAddStates(3, 5);
                                }

                                break;
                            case 11:
                                if ((0xfffffffbffffdbffUL & (ulong)l) != 0L)
                                {
                                    jjCheckNAddStates(3, 5);
                                }

                                break;
                            case 12:
                                if (character == 34 && kind > 24)
                                {
                                    kind = 24;
                                }

                                break;
                            case 14:
                                if ((0x8400000000L & l) != 0L)
                                {
                                    jjCheckNAddStates(3, 5);
                                }

                                break;
                            case 15:
                                if ((0xff000000000000L & l) != 0L)
                                {
                                    jjCheckNAddStates(9, 12);
                                }

                                break;
                            case 16:
                                if ((0xff000000000000L & l) != 0L)
                                {
                                    jjCheckNAddStates(3, 5);
                                }

                                break;
                            case 17:
                                if ((0xf000000000000L & l) != 0L)
                                {
                                    jjstateSet[jjnewStateCnt++] = 18;
                                }

                                break;
                            case 18:
                                if ((0xff000000000000L & l) != 0L)
                                {
                                    jjCheckNAdd(16);
                                }

                                break;
                            case 19:
                                if (character == 32)
                                {
                                    jjAddStates(13, 14);
                                }

                                break;
                            case 20:
                                if (character == 10)
                                {
                                    jjCheckNAddStates(3, 5);
                                }

                                break;
                            case 21:
                                if (character == 39)
                                {
                                    jjCheckNAddStates(0, 2);
                                }

                                break;
                            case 22:
                                if ((0xffffff7fffffdbffUL & (ulong)l) != 0L)
                                {
                                    jjCheckNAddStates(0, 2);
                                }

                                break;
                            case 24:
                                if (character == 32)
                                {
                                    jjAddStates(15, 16);
                                }

                                break;
                            case 25:
                                if (character == 10)
                                {
                                    jjCheckNAddStates(0, 2);
                                }

                                break;
                            case 26:
                                if (character == 39 && kind > 24)
                                {
                                    kind = 24;
                                }

                                break;
                            case 27:
                                if ((0x2400L & l) != 0L && kind > 27)
                                {
                                    kind = 27;
                                }

                                break;
                            case 28:
                                if (character == 10 && kind > 27)
                                {
                                    kind = 27;
                                }

                                break;
                            case 29:
                                if (character == 13)
                                {
                                    jjstateSet[jjnewStateCnt++] = 28;
                                }

                                break;
                            case 30:
                                if (character == 45)
                                {
                                    jjCheckNAdd(31);
                                }

                                break;
                            case 31:
                                if ((0x3ff000000000000L & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 49)
                                {
                                    kind = 49;
                                }

                                jjCheckNAdd(31);
                                break;
                            case 33:
                                if ((0x3ff000000000000L & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 52)
                                {
                                    kind = 52;
                                }

                                jjstateSet[jjnewStateCnt++] = 33;
                                break;
                            case 36:
                                if (character == 36 && kind > 10)
                                {
                                    kind = 10;
                                }

                                break;
                            case 38:
                                if (character == 36)
                                {
                                    jjCheckNAddTwoStates(39, 40);
                                }

                                break;
                            case 40:
                                if (character == 33 && kind > 11)
                                {
                                    kind = 11;
                                }

                                break;
                            case 41:
                                if (character != 36)
                                {
                                    break;
                                }

                                if (kind > 10)
                                {
                                    kind = 10;
                                }

                                jjCheckNAddTwoStates(39, 40);
                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else if (character < 128)
                {
                    long l = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 0:
                                if ((0x7fffffe87fffffeL & l) != 0L)
                                {
                                    if (kind > 52)
                                    {
                                        kind = 52;
                                    }

                                    jjCheckNAdd(33);
                                }
                                else if (character == 92)
                                {
                                    jjCheckNAddStates(17, 20);
                                }

                                break;
                            case 6:
                                if (kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 11:
                                if ((0xffffffffefffffffUL & (ulong)l) != 0L)
                                {
                                    jjCheckNAddStates(3, 5);
                                }

                                break;
                            case 13:
                                if (character == 92)
                                {
                                    jjAddStates(21, 25);
                                }

                                break;
                            case 14:
                                if ((0x14404410000000L & l) != 0L)
                                {
                                    jjCheckNAddStates(3, 5);
                                }

                                break;
                            case 22:
                                jjAddStates(0, 2);
                                break;
                            case 23:
                                if (character == 92)
                                {
                                    jjAddStates(15, 16);
                                }

                                break;
                            case 32:
                            case 33:
                                if ((0x7fffffe87fffffeL & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 52)
                                {
                                    kind = 52;
                                }

                                jjCheckNAdd(33);
                                break;
                            case 34:
                                if (character == 92)
                                {
                                    jjCheckNAddStates(17, 20);
                                }

                                break;
                            case 35:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(35, 36);
                                }

                                break;
                            case 37:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(37, 38);
                                }

                                break;
                            case 39:
                                if (character == 92)
                                {
                                    jjAddStates(26, 27);
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = character >> 8;
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (character & 0xff) >> 6;
                    long l2 = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 6:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 11:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                                {
                                    jjAddStates(3, 5);
                                }

                                break;
                            case 22:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                                {
                                    jjAddStates(0, 2);
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 42 - (jjnewStateCnt = startsAt)))
                {
                    return curPos;
                }

                if (!input_stream.ReadChar())
                {
                    return curPos;
                }
            }
        }

        private int jjStopStringLiteralDfa_6(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0xd000L) != 0L)
                    {
                        return 2;
                    }

                    return -1;
                default:
                    return -1;
            }
        }

        private int jjStartNfa_6(int pos, long active0)
        {
            return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0), pos + 1);
        }

        private int jjStartNfaWithStates_6(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            if (!input_stream.ReadChar())
            {
                return pos + 1;
            }
            return jjMoveNfa_6(state, pos + 1);
        }

        private int jjMoveStringLiteralDfa0_6()
        {
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    jjmatchedKind = 15;
                    return jjMoveStringLiteralDfa1_6(0x5000L);
                case (char)42:
                    return jjMoveStringLiteralDfa1_6(0x200000L);
                default:
                    return jjMoveNfa_6(3, 0);
            }
        }

        private int jjMoveStringLiteralDfa1_6(long active0)
        {
            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_6(0, active0);
                return 1;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    if ((active0 & 0x1000L) != 0L)
                    {
                        return jjStopAtPos(1, 12);
                    }
                    else if ((active0 & 0x200000L) != 0L)
                    {
                        return jjStopAtPos(1, 21);
                    }

                    break;
                case (char)42:
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return jjStartNfaWithStates_6(1, 14, 0);
                    }

                    break;
                default:
                    break;
            }
            return jjStartNfa_6(0, active0);
        }

        private int jjMoveNfa_6(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 12;
            int i = 1;
            jjstateSet[0] = (uint)startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                {
                    ReInitRounds();
                }

                char character = input_stream.CurrentCharacter;
                if (character < 64)
                {
                    long l = 1L << character;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (character == 36)
                                {
                                    if (kind > 10)
                                    {
                                        kind = 10;
                                    }

                                    jjCheckNAddTwoStates(9, 10);
                                }
                                else if (character == 35)
                                {
                                    jjstateSet[jjnewStateCnt++] = 2;
                                }

                                break;
                            case 0:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 1;
                                }

                                break;
                            case 1:
                                if ((0xfffffff7ffffffffUL & (ulong)l) != 0L && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 2:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 0;
                                }

                                break;
                            case 6:
                                if (character == 36 && kind > 10)
                                {
                                    kind = 10;
                                }

                                break;
                            case 8:
                                if (character == 36)
                                {
                                    jjCheckNAddTwoStates(9, 10);
                                }

                                break;
                            case 10:
                                if (character == 33 && kind > 11)
                                {
                                    kind = 11;
                                }

                                break;
                            case 11:
                                if (character != 36)
                                {
                                    break;
                                }

                                if (kind > 10)
                                {
                                    kind = 10;
                                }

                                jjCheckNAddTwoStates(9, 10);
                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else if (character < 128)
                {
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (character == 92)
                                {
                                    jjCheckNAddStates(28, 31);
                                }

                                break;
                            case 1:
                                if (kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 5:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(5, 6);
                                }

                                break;
                            case 7:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(7, 8);
                                }

                                break;
                            case 9:
                                if (character == 92)
                                {
                                    jjAddStates(32, 33);
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (character >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (character & 0xff) >> 6;
                    long l2 = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
                {
                    return curPos;
                }

                if (!input_stream.ReadChar())
                {
                    return curPos;
                }
            }
        }

        private int jjStopStringLiteralDfa_4(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0xd000L) != 0L)
                    {
                        return 2;
                    }

                    if ((active0 & 0x200000000000L) != 0L)
                    {
                        jjmatchedKind = 52;
                        return 22;
                    }
                    if ((active0 & 0x900000000000L) != 0L)
                    {
                        jjmatchedKind = 52;
                        return 7;
                    }
                    return -1;
                case 1:
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return 0;
                    }

                    if ((active0 & 0x200000000000L) != 0L)
                    {
                        jjmatchedKind = 52;
                        jjmatchedPos = 1;
                        return 28;
                    }
                    if ((active0 & 0x800000000000L) != 0L)
                    {
                        jjmatchedKind = 52;
                        jjmatchedPos = 1;
                        return 7;
                    }
                    if ((active0 & 0x100000000000L) != 0L)
                    {
                        return 7;
                    }

                    return -1;
                case 2:
                    if ((active0 & 0x200000000000L) != 0L)
                    {
                        jjmatchedKind = 52;
                        jjmatchedPos = 2;
                        return 23;
                    }
                    if ((active0 & 0x800000000000L) != 0L)
                    {
                        jjmatchedKind = 52;
                        jjmatchedPos = 2;
                        return 7;
                    }
                    return -1;
                case 3:
                    if ((active0 & 0x800000000000L) != 0L)
                    {
                        return 7;
                    }

                    if ((active0 & 0x200000000000L) != 0L)
                    {
                        jjmatchedKind = 46;
                        jjmatchedPos = 3;
                        return 30;
                    }
                    return -1;
                case 4:
                    if ((active0 & 0x200000000000L) != 0L)
                    {
                        jjmatchedKind = 52;
                        jjmatchedPos = 4;
                        return 7;
                    }
                    return -1;
                default:
                    return -1;
            }
        }

        private int jjStartNfa_4(int pos, long active0)
        {
            return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
        }

        private int jjStartNfaWithStates_4(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            if (!input_stream.ReadChar())
            {
                return pos + 1;
            }
            return jjMoveNfa_4(state, pos + 1);
        }

        private int jjMoveStringLiteralDfa0_4()
        {
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    jjmatchedKind = 15;
                    return jjMoveStringLiteralDfa1_4(0x5000L);
                case (char)101:
                    return jjMoveStringLiteralDfa1_4(0x200000000000L);
                case (char)105:
                    return jjMoveStringLiteralDfa1_4(0x100000000000L);
                case (char)115:
                    return jjMoveStringLiteralDfa1_4(0x800000000000L);
                default:
                    return jjMoveNfa_4(3, 0);
            }
        }

        private int jjMoveStringLiteralDfa1_4(long active0)
        {
            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_4(0, active0);
                return 1;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    if ((active0 & 0x1000L) != 0L)
                    {
                        return jjStopAtPos(1, 12);
                    }

                    break;
                case (char)42:
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return jjStartNfaWithStates_4(1, 14, 0);
                    }

                    break;
                case (char)102:
                    if ((active0 & 0x100000000000L) != 0L)
                    {
                        return jjStartNfaWithStates_4(1, 44, 7);
                    }

                    break;
                case (char)108:
                    return jjMoveStringLiteralDfa2_4(active0, 0x200000000000L);
                case (char)116:
                    return jjMoveStringLiteralDfa2_4(active0, 0x800000000000L);
                default:
                    break;
            }
            return jjStartNfa_4(0, active0);
        }

        private int jjMoveStringLiteralDfa2_4(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_4(0, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_4(1, active0);
                return 2;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)111:
                    return jjMoveStringLiteralDfa3_4(active0, 0x800000000000L);
                case (char)115:
                    return jjMoveStringLiteralDfa3_4(active0, 0x200000000000L);
                default:
                    break;
            }
            return jjStartNfa_4(1, active0);
        }

        private int jjMoveStringLiteralDfa3_4(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_4(1, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_4(2, active0);
                return 3;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)101:
                    return jjMoveStringLiteralDfa4_4(active0, 0x200000000000L);
                case (char)112:
                    if ((active0 & 0x800000000000L) != 0L)
                    {
                        return jjStartNfaWithStates_4(3, 47, 7);
                    }

                    break;
                default:
                    break;
            }
            return jjStartNfa_4(2, active0);
        }

        private int jjMoveStringLiteralDfa4_4(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_4(2, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_4(3, active0);
                return 4;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)105:
                    return jjMoveStringLiteralDfa5_4(active0, 0x200000000000L);
                default:
                    break;
            }
            return jjStartNfa_4(3, active0);
        }

        private int jjMoveStringLiteralDfa5_4(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_4(3, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_4(4, active0);
                return 5;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)102:
                    if ((active0 & 0x200000000000L) != 0L)
                    {
                        return jjStartNfaWithStates_4(5, 45, 7);
                    }

                    break;
                default:
                    break;
            }
            return jjStartNfa_4(4, active0);
        }

        private int jjMoveNfa_4(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 30;
            int i = 1;
            jjstateSet[0] = (uint)startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                {
                    ReInitRounds();
                }

                char character = input_stream.CurrentCharacter;
                if (character < 64)
                {
                    long l = 1L << character;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if ((0x3ff000000000000L & l) != 0L)
                                {
                                    if (kind > 49)
                                    {
                                        kind = 49;
                                    }

                                    jjCheckNAdd(5);
                                }
                                else if (character == 36)
                                {
                                    if (kind > 10)
                                    {
                                        kind = 10;
                                    }

                                    jjCheckNAddTwoStates(13, 14);
                                }
                                else if (character == 45)
                                {
                                    jjCheckNAdd(5);
                                }
                                else if (character == 35)
                                {
                                    jjstateSet[jjnewStateCnt++] = 2;
                                }

                                break;
                            case 30:
                                if ((0x3ff000000000000L & l) != 0L)
                                {
                                    if (kind > 52)
                                    {
                                        kind = 52;
                                    }

                                    jjCheckNAdd(7);
                                }
                                else if ((0x2400L & l) != 0L)
                                {
                                    if (kind > 46)
                                    {
                                        kind = 46;
                                    }
                                }
                                else if ((0x100000200L & l) != 0L)
                                {
                                    jjCheckNAddStates(34, 36);
                                }

                                if (character == 13)
                                {
                                    jjstateSet[jjnewStateCnt++] = 26;
                                }

                                break;
                            case 22:
                            case 7:
                                if ((0x3ff000000000000L & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 52)
                                {
                                    kind = 52;
                                }

                                jjCheckNAdd(7);
                                break;
                            case 28:
                                if ((0x3ff000000000000L & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 52)
                                {
                                    kind = 52;
                                }

                                jjCheckNAdd(7);
                                break;
                            case 23:
                                if ((0x3ff000000000000L & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 52)
                                {
                                    kind = 52;
                                }

                                jjCheckNAdd(7);
                                break;
                            case 0:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 1;
                                }

                                break;
                            case 1:
                                if ((0xfffffff7ffffffffUL & (ulong)l) != 0L && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 2:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 0;
                                }

                                break;
                            case 4:
                                if (character == 45)
                                {
                                    jjCheckNAdd(5);
                                }

                                break;
                            case 5:
                                if ((0x3ff000000000000L & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 49)
                                {
                                    kind = 49;
                                }

                                jjCheckNAdd(5);
                                break;
                            case 10:
                                if (character == 36 && kind > 10)
                                {
                                    kind = 10;
                                }

                                break;
                            case 12:
                                if (character == 36)
                                {
                                    jjCheckNAddTwoStates(13, 14);
                                }

                                break;
                            case 14:
                                if (character == 33 && kind > 11)
                                {
                                    kind = 11;
                                }

                                break;
                            case 15:
                                if (character != 36)
                                {
                                    break;
                                }

                                if (kind > 10)
                                {
                                    kind = 10;
                                }

                                jjCheckNAddTwoStates(13, 14);
                                break;
                            case 18:
                                if ((0x100000200L & l) != 0L)
                                {
                                    jjAddStates(37, 39);
                                }

                                break;
                            case 19:
                                if ((0x2400L & l) != 0L && kind > 43)
                                {
                                    kind = 43;
                                }

                                break;
                            case 20:
                                if (character == 10 && kind > 43)
                                {
                                    kind = 43;
                                }

                                break;
                            case 21:
                                if (character == 13)
                                {
                                    jjstateSet[jjnewStateCnt++] = 20;
                                }

                                break;
                            case 24:
                                if ((0x100000200L & l) != 0L)
                                {
                                    jjCheckNAddStates(34, 36);
                                }

                                break;
                            case 25:
                                if ((0x2400L & l) != 0L && kind > 46)
                                {
                                    kind = 46;
                                }

                                break;
                            case 26:
                                if (character == 10 && kind > 46)
                                {
                                    kind = 46;
                                }

                                break;
                            case 27:
                                if (character == 13)
                                {
                                    jjstateSet[jjnewStateCnt++] = 26;
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else if (character < 128)
                {
                    long l = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if ((0x7fffffe87fffffeL & l) != 0L)
                                {
                                    if (kind > 52)
                                    {
                                        kind = 52;
                                    }

                                    jjCheckNAdd(7);
                                }
                                else if (character == 92)
                                {
                                    jjCheckNAddStates(40, 43);
                                }

                                if (character == 101)
                                {
                                    jjAddStates(44, 45);
                                }

                                break;
                            case 30:
                            case 7:
                                if ((0x7fffffe87fffffeL & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 52)
                                {
                                    kind = 52;
                                }

                                jjCheckNAdd(7);
                                break;
                            case 22:
                                if ((0x7fffffe87fffffeL & l) != 0L)
                                {
                                    if (kind > 52)
                                    {
                                        kind = 52;
                                    }

                                    jjCheckNAdd(7);
                                }
                                if (character == 108)
                                {
                                    jjstateSet[jjnewStateCnt++] = 28;
                                }
                                else if (character == 110)
                                {
                                    jjstateSet[jjnewStateCnt++] = 17;
                                }

                                break;
                            case 28:
                                if ((0x7fffffe87fffffeL & l) != 0L)
                                {
                                    if (kind > 52)
                                    {
                                        kind = 52;
                                    }

                                    jjCheckNAdd(7);
                                }
                                if (character == 115)
                                {
                                    jjstateSet[jjnewStateCnt++] = 23;
                                }

                                break;
                            case 23:
                                if ((0x7fffffe87fffffeL & l) != 0L)
                                {
                                    if (kind > 52)
                                    {
                                        kind = 52;
                                    }

                                    jjCheckNAdd(7);
                                }
                                if (character == 101)
                                {
                                    if (kind > 46)
                                    {
                                        kind = 46;
                                    }

                                    jjAddStates(34, 36);
                                }
                                break;
                            case 1:
                                if (kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 6:
                                if ((0x7fffffe87fffffeL & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 52)
                                {
                                    kind = 52;
                                }

                                jjCheckNAdd(7);
                                break;
                            case 8:
                                if (character == 92)
                                {
                                    jjCheckNAddStates(40, 43);
                                }

                                break;
                            case 9:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(9, 10);
                                }

                                break;
                            case 11:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(11, 12);
                                }

                                break;
                            case 13:
                                if (character == 92)
                                {
                                    jjAddStates(46, 47);
                                }

                                break;
                            case 16:
                                if (character == 101)
                                {
                                    jjAddStates(44, 45);
                                }

                                break;
                            case 17:
                                if (character != 100)
                                {
                                    break;
                                }

                                if (kind > 43)
                                {
                                    kind = 43;
                                }

                                jjAddStates(37, 39);
                                break;
                            case 29:
                                if (character == 108)
                                {
                                    jjstateSet[jjnewStateCnt++] = 28;
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (character >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (character & 0xff) >> 6;
                    long l2 = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 30 - (jjnewStateCnt = startsAt)))
                {
                    return curPos;
                }

                if (!input_stream.ReadChar())
                {
                    return curPos;
                }
            }
        }

        private int jjStopStringLiteralDfa_3(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0x30000L) != 0L)
                    {
                        return 7;
                    }

                    if ((active0 & 0xd000L) != 0L)
                    {
                        return 14;
                    }

                    return -1;
                default:
                    return -1;
            }
        }

        private int jjStartNfa_3(int pos, long active0)
        {
            return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
        }

        private int jjStartNfaWithStates_3(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            if (!input_stream.ReadChar())
            {
                return pos + 1;
            }
            return jjMoveNfa_3(state, pos + 1);
        }

        private int jjMoveStringLiteralDfa0_3()
        {
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    jjmatchedKind = 15;
                    return jjMoveStringLiteralDfa1_3(0x5000L);
                case (char)92:
                    jjmatchedKind = 17;
                    return jjMoveStringLiteralDfa1_3(0x10000L);
                default:
                    return jjMoveNfa_3(11, 0);
            }
        }

        private int jjMoveStringLiteralDfa1_3(long active0)
        {
            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_3(0, active0);
                return 1;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    if ((active0 & 0x1000L) != 0L)
                    {
                        return jjStopAtPos(1, 12);
                    }

                    break;
                case (char)42:
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return jjStartNfaWithStates_3(1, 14, 12);
                    }

                    break;
                case (char)92:
                    if ((active0 & 0x10000L) != 0L)
                    {
                        return jjStartNfaWithStates_3(1, 16, 23);
                    }

                    break;
                default:
                    break;
            }
            return jjStartNfa_3(0, active0);
        }

        private int jjMoveNfa_3(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 23;
            int i = 1;
            jjstateSet[0] = (uint)startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                {
                    ReInitRounds();
                }

                char character = input_stream.CurrentCharacter;
                if (character < 64)
                {
                    long l = 1L << character;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 23:
                                if (character == 36)
                                {
                                    jjCheckNAddTwoStates(20, 21);
                                }

                                if (character == 36)
                                {
                                    if (kind > 10)
                                    {
                                        kind = 10;
                                    }
                                }
                                break;
                            case 7:
                                if (character == 36)
                                {
                                    jjCheckNAddTwoStates(20, 21);
                                }
                                else if (character == 35)
                                {
                                    jjstateSet[jjnewStateCnt++] = 9;
                                }

                                if (character == 36)
                                {
                                    if (kind > 10)
                                    {
                                        kind = 10;
                                    }
                                }
                                break;
                            case 14:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 12;
                                }

                                break;
                            case 11:
                                if ((0xffffffe7ffffffffUL & (ulong)l) != 0L)
                                {
                                    if (kind > 18)
                                    {
                                        kind = 18;
                                    }

                                    jjCheckNAdd(5);
                                }
                                else if (character == 36)
                                {
                                    if (kind > 10)
                                    {
                                        kind = 10;
                                    }

                                    jjCheckNAddTwoStates(20, 21);
                                }
                                else if (character == 35)
                                {
                                    jjCheckNAddTwoStates(3, 14);
                                }

                                if ((0x100000200L & l) != 0L)
                                {
                                    jjCheckNAddTwoStates(0, 4);
                                }

                                break;
                            case 0:
                                if ((0x100000200L & l) != 0L)
                                {
                                    jjCheckNAddTwoStates(0, 4);
                                }

                                break;
                            case 4:
                                if (character == 35)
                                {
                                    jjCheckNAdd(3);
                                }

                                break;
                            case 5:
                                if ((0xffffffe7ffffffffUL & (ulong)l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 18)
                                {
                                    kind = 18;
                                }

                                jjCheckNAdd(5);
                                break;
                            case 8:
                                if (character == 35)
                                {
                                    jjstateSet[jjnewStateCnt++] = 9;
                                }

                                break;
                            case 10:
                                if ((0x3ff000000000000L & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 8)
                                {
                                    kind = 8;
                                }

                                jjstateSet[jjnewStateCnt++] = 10;
                                break;
                            case 12:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 13;
                                }

                                break;
                            case 13:
                                if ((0xfffffff7ffffffffUL & (ulong)l) != 0L && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 17:
                                if (character == 36 && kind > 10)
                                {
                                    kind = 10;
                                }

                                break;
                            case 19:
                                if (character == 36)
                                {
                                    jjCheckNAddTwoStates(20, 21);
                                }

                                break;
                            case 21:
                                if (character == 33 && kind > 11)
                                {
                                    kind = 11;
                                }

                                break;
                            case 22:
                                if (character != 36)
                                {
                                    break;
                                }

                                if (kind > 10)
                                {
                                    kind = 10;
                                }

                                jjCheckNAddTwoStates(20, 21);
                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else if (character < 128)
                {
                    long l = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 23:
                                if (character == 92)
                                {
                                    jjAddStates(48, 49);
                                }

                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(18, 19);
                                }

                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(16, 17);
                                }

                                break;
                            case 7:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(18, 19);
                                }

                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(16, 17);
                                }

                                if (character == 92)
                                {
                                    jjstateSet[jjnewStateCnt++] = 6;
                                }

                                break;
                            case 14:
                            case 3:
                                if (character == 115)
                                {
                                    jjstateSet[jjnewStateCnt++] = 2;
                                }

                                break;
                            case 11:
                                if ((0xffffffffefffffffUL & (ulong)l) != 0L)
                                {
                                    if (kind > 18)
                                    {
                                        kind = 18;
                                    }

                                    jjCheckNAdd(5);
                                }
                                else if (character == 92)
                                {
                                    jjCheckNAddStates(50, 53);
                                }

                                if (character == 92)
                                {
                                    jjAddStates(48, 49);
                                }

                                break;
                            case 1:
                                if (character == 116 && kind > 9)
                                {
                                    kind = 9;
                                }

                                break;
                            case 2:
                                if (character == 101)
                                {
                                    jjstateSet[jjnewStateCnt++] = 1;
                                }

                                break;
                            case 5:
                                if ((0xffffffffefffffffUL & (ulong)l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 18)
                                {
                                    kind = 18;
                                }

                                jjCheckNAdd(5);
                                break;
                            case 6:
                                if (character == 92)
                                {
                                    jjAddStates(48, 49);
                                }

                                break;
                            case 9:
                            case 10:
                                if ((0x7fffffe87fffffeL & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 8)
                                {
                                    kind = 8;
                                }

                                jjCheckNAdd(10);
                                break;
                            case 13:
                                if (kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 15:
                                if (character == 92)
                                {
                                    jjCheckNAddStates(50, 53);
                                }

                                break;
                            case 16:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(16, 17);
                                }

                                break;
                            case 18:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(18, 19);
                                }

                                break;
                            case 20:
                                if (character == 92)
                                {
                                    jjAddStates(54, 55);
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (character >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (character & 0xff) >> 6;
                    long l2 = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 11:
                            case 5:
                                if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                                {
                                    break;
                                }

                                if (kind > 18)
                                {
                                    kind = 18;
                                }

                                jjCheckNAdd(5);
                                break;
                            case 13:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 23 - (jjnewStateCnt = startsAt)))
                {
                    return curPos;
                }

                if (!input_stream.ReadChar())
                {
                    return curPos;
                    // TODO:  added because this is what will happen when you read past the end of the buffer
                    //} catch (IndexOutOfRangeException ex) {
                    //    return curPos;
                }
            }
        }

        private int jjStopStringLiteralDfa_7(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0xd000L) != 0L)
                    {
                        return 2;
                    }

                    return -1;
                default:
                    return -1;
            }
        }

        private int jjStartNfa_7(int pos, long active0)
        {
            return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
        }

        private int jjStartNfaWithStates_7(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            if (!input_stream.ReadChar())
            {
                return pos + 1;
            }
            return jjMoveNfa_7(state, pos + 1);
        }

        private int jjMoveStringLiteralDfa0_7()
        {
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    jjmatchedKind = 15;
                    return jjMoveStringLiteralDfa1_7(0x5000L);
                case (char)42:
                    return jjMoveStringLiteralDfa1_7(0x100000L);
                default:
                    return jjMoveNfa_7(3, 0);
            }
        }

        private int jjMoveStringLiteralDfa1_7(long active0)
        {
            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_7(0, active0);
                return 1;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    if ((active0 & 0x1000L) != 0L)
                    {
                        return jjStopAtPos(1, 12);
                    }
                    else if ((active0 & 0x100000L) != 0L)
                    {
                        return jjStopAtPos(1, 20);
                    }

                    break;
                case (char)42:
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return jjStartNfaWithStates_7(1, 14, 0);
                    }

                    break;
                default:
                    break;
            }
            return jjStartNfa_7(0, active0);
        }

        private int jjMoveNfa_7(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 12;
            int i = 1;
            jjstateSet[0] = (uint)startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                {
                    ReInitRounds();
                }

                char character = input_stream.CurrentCharacter;
                if (character < 64)
                {
                    long l = 1L << character;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (character == 36)
                                {
                                    if (kind > 10)
                                    {
                                        kind = 10;
                                    }

                                    jjCheckNAddTwoStates(9, 10);
                                }
                                else if (character == 35)
                                {
                                    jjstateSet[jjnewStateCnt++] = 2;
                                }

                                break;
                            case 0:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 1;
                                }

                                break;
                            case 1:
                                if ((0xfffffff7ffffffffUL & (ulong)l) != 0L && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 2:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 0;
                                }

                                break;
                            case 6:
                                if (character == 36 && kind > 10)
                                {
                                    kind = 10;
                                }

                                break;
                            case 8:
                                if (character == 36)
                                {
                                    jjCheckNAddTwoStates(9, 10);
                                }

                                break;
                            case 10:
                                if (character == 33 && kind > 11)
                                {
                                    kind = 11;
                                }

                                break;
                            case 11:
                                if (character != 36)
                                {
                                    break;
                                }

                                if (kind > 10)
                                {
                                    kind = 10;
                                }

                                jjCheckNAddTwoStates(9, 10);
                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else if (character < 128)
                {
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (character == 92)
                                {
                                    jjCheckNAddStates(28, 31);
                                }

                                break;
                            case 1:
                                if (kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 5:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(5, 6);
                                }

                                break;
                            case 7:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(7, 8);
                                }

                                break;
                            case 9:
                                if (character == 92)
                                {
                                    jjAddStates(32, 33);
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (character >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (character & 0xff) >> 6;
                    long l2 = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
                {
                    return curPos;
                }

                if (!input_stream.ReadChar())
                {
                    return curPos;
                }
            }
        }

        private int jjStopStringLiteralDfa_8(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0xd000L) != 0L)
                    {
                        return 2;
                    }

                    return -1;
                default:
                    return -1;
            }
        }

        private int jjStartNfa_8(int pos, long active0)
        {
            return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1);
        }

        private int jjStartNfaWithStates_8(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            if (!input_stream.ReadChar())
            {
                return pos + 1;
            }
            return jjMoveNfa_8(state, pos + 1);
        }

        private int jjMoveStringLiteralDfa0_8()
        {
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    jjmatchedKind = 15;
                    return jjMoveStringLiteralDfa1_8(0x5000L);
                default:
                    return jjMoveNfa_8(3, 0);
            }
        }

        private int jjMoveStringLiteralDfa1_8(long active0)
        {
            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_8(0, active0);
                return 1;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    if ((active0 & 0x1000L) != 0L)
                    {
                        return jjStopAtPos(1, 12);
                    }

                    break;
                case (char)42:
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return jjStartNfaWithStates_8(1, 14, 0);
                    }

                    break;
                default:
                    break;
            }
            return jjStartNfa_8(0, active0);
        }

        private int jjMoveNfa_8(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 15;
            int i = 1;
            jjstateSet[0] = (uint)startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                {
                    ReInitRounds();
                }

                char character = input_stream.CurrentCharacter;
                if (character < 64)
                {
                    long l = 1L << character;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if ((0x2400L & l) != 0L)
                                {
                                    if (kind > 19)
                                    {
                                        kind = 19;
                                    }
                                }
                                else if (character == 36)
                                {
                                    if (kind > 10)
                                    {
                                        kind = 10;
                                    }

                                    jjCheckNAddTwoStates(12, 13);
                                }
                                else if (character == 35)
                                {
                                    jjstateSet[jjnewStateCnt++] = 2;
                                }

                                if (character == 13)
                                {
                                    jjstateSet[jjnewStateCnt++] = 5;
                                }

                                break;
                            case 0:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 1;
                                }

                                break;
                            case 1:
                                if ((0xfffffff7ffffffffUL & (ulong)l) != 0L && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 2:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 0;
                                }

                                break;
                            case 4:
                                if ((0x2400L & l) != 0L && kind > 19)
                                {
                                    kind = 19;
                                }

                                break;
                            case 5:
                                if (character == 10 && kind > 19)
                                {
                                    kind = 19;
                                }

                                break;
                            case 6:
                                if (character == 13)
                                {
                                    jjstateSet[jjnewStateCnt++] = 5;
                                }

                                break;
                            case 9:
                                if (character == 36 && kind > 10)
                                {
                                    kind = 10;
                                }

                                break;
                            case 11:
                                if (character == 36)
                                {
                                    jjCheckNAddTwoStates(12, 13);
                                }

                                break;
                            case 13:
                                if (character == 33 && kind > 11)
                                {
                                    kind = 11;
                                }

                                break;
                            case 14:
                                if (character != 36)
                                {
                                    break;
                                }

                                if (kind > 10)
                                {
                                    kind = 10;
                                }

                                jjCheckNAddTwoStates(12, 13);
                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else if (character < 128)
                {
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (character == 92)
                                {
                                    jjCheckNAddStates(56, 59);
                                }

                                break;
                            case 1:
                                if (kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 8:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(8, 9);
                                }

                                break;
                            case 10:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(10, 11);
                                }

                                break;
                            case 12:
                                if (character == 92)
                                {
                                    jjAddStates(60, 61);
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (character >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (character & 0xff) >> 6;
                    long l2 = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 15 - (jjnewStateCnt = startsAt)))
                {
                    return curPos;
                }

                if (!input_stream.ReadChar())
                {
                    return curPos;
                }
            }
        }

        private int jjStopStringLiteralDfa_5(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0xd000L) != 0L)
                    {
                        return 2;
                    }

                    if ((active0 & 0x6000000L) != 0L)
                    {
                        jjmatchedKind = 56;
                        return 5;
                    }
                    return -1;
                case 1:
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return 0;
                    }

                    if ((active0 & 0x6000000L) != 0L)
                    {
                        jjmatchedKind = 56;
                        jjmatchedPos = 1;
                        return 5;
                    }
                    return -1;
                case 2:
                    if ((active0 & 0x6000000L) != 0L)
                    {
                        jjmatchedKind = 56;
                        jjmatchedPos = 2;
                        return 5;
                    }
                    return -1;
                case 3:
                    if ((active0 & 0x4000000L) != 0L)
                    {
                        jjmatchedKind = 56;
                        jjmatchedPos = 3;
                        return 5;
                    }
                    if ((active0 & 0x2000000L) != 0L)
                    {
                        return 5;
                    }

                    return -1;
                default:
                    return -1;
            }
        }

        private int jjStartNfa_5(int pos, long active0)
        {
            return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1);
        }

        private int jjStartNfaWithStates_5(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            if (!input_stream.ReadChar())
            {
                return pos + 1;
            }
            return jjMoveNfa_5(state, pos + 1);
        }

        private int jjMoveStringLiteralDfa0_5()
        {
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    jjmatchedKind = 15;
                    return jjMoveStringLiteralDfa1_5(0x5000L);
                case (char)102:
                    return jjMoveStringLiteralDfa1_5(0x4000000L);
                case (char)116:
                    return jjMoveStringLiteralDfa1_5(0x2000000L);
                case (char)123:
                    return jjStopAtPos(0, 58);
                case (char)125:
                    return jjStopAtPos(0, 59);
                default:
                    return jjMoveNfa_5(3, 0);
            }
        }

        private int jjMoveStringLiteralDfa1_5(long active0)
        {
            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_5(0, active0);
                return 1;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    if ((active0 & 0x1000L) != 0L)
                    {
                        return jjStopAtPos(1, 12);
                    }

                    break;
                case (char)42:
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return jjStartNfaWithStates_5(1, 14, 0);
                    }

                    break;
                case (char)97:
                    return jjMoveStringLiteralDfa2_5(active0, 0x4000000L);
                case (char)114:
                    return jjMoveStringLiteralDfa2_5(active0, 0x2000000L);
                default:
                    break;
            }
            return jjStartNfa_5(0, active0);
        }

        private int jjMoveStringLiteralDfa2_5(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_5(0, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_5(1, active0);
                return 2;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)108:
                    return jjMoveStringLiteralDfa3_5(active0, 0x4000000L);
                case (char)117:
                    return jjMoveStringLiteralDfa3_5(active0, 0x2000000L);
                default:
                    break;
            }
            return jjStartNfa_5(1, active0);
        }

        private int jjMoveStringLiteralDfa3_5(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_5(1, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_5(2, active0);
                return 3;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)101:
                    if ((active0 & 0x2000000L) != 0L)
                    {
                        return jjStartNfaWithStates_5(3, 25, 5);
                    }

                    break;
                case (char)115:
                    return jjMoveStringLiteralDfa4_5(active0, 0x4000000L);
                default:
                    break;
            }
            return jjStartNfa_5(2, active0);
        }

        private int jjMoveStringLiteralDfa4_5(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_5(2, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_5(3, active0);
                return 4;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)101:
                    if ((active0 & 0x4000000L) != 0L)
                    {
                        return jjStartNfaWithStates_5(4, 26, 5);
                    }

                    break;
                default:
                    break;
            }
            return jjStartNfa_5(3, active0);
        }

        private int jjMoveNfa_5(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 16;
            int i = 1;
            jjstateSet[0] = (uint)startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                {
                    ReInitRounds();
                }

                char character = input_stream.CurrentCharacter;
                if (character < 64)
                {
                    long l = 1L << character;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (character == 36)
                                {
                                    if (kind > 10)
                                    {
                                        kind = 10;
                                    }

                                    jjCheckNAddTwoStates(13, 14);
                                }
                                else if (character == 46)
                                {
                                    jjstateSet[jjnewStateCnt++] = 7;
                                }
                                else if (character == 35)
                                {
                                    jjstateSet[jjnewStateCnt++] = 2;
                                }

                                break;
                            case 0:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 1;
                                }

                                break;
                            case 1:
                                if ((0xfffffff7ffffffffUL & (ulong)l) != 0L && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 2:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 0;
                                }

                                break;
                            case 5:
                                if ((0x3ff200000000000L & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 56)
                                {
                                    kind = 56;
                                }

                                jjstateSet[jjnewStateCnt++] = 5;
                                break;
                            case 6:
                                if (character == 46)
                                {
                                    jjstateSet[jjnewStateCnt++] = 7;
                                }

                                break;
                            case 10:
                                if (character == 36 && kind > 10)
                                {
                                    kind = 10;
                                }

                                break;
                            case 12:
                                if (character == 36)
                                {
                                    jjCheckNAddTwoStates(13, 14);
                                }

                                break;
                            case 14:
                                if (character == 33 && kind > 11)
                                {
                                    kind = 11;
                                }

                                break;
                            case 15:
                                if (character != 36)
                                {
                                    break;
                                }

                                if (kind > 10)
                                {
                                    kind = 10;
                                }

                                jjCheckNAddTwoStates(13, 14);
                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else if (character < 128)
                {
                    long l = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if ((0x7fffffe87fffffeL & l) != 0L)
                                {
                                    if (kind > 56)
                                    {
                                        kind = 56;
                                    }

                                    jjCheckNAdd(5);
                                }
                                else if (character == 92)
                                {
                                    jjCheckNAddStates(40, 43);
                                }

                                break;
                            case 1:
                                if (kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 4:
                            case 5:
                                if ((0x7fffffe87fffffeL & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 56)
                                {
                                    kind = 56;
                                }

                                jjCheckNAdd(5);
                                break;
                            case 7:
                                if ((0x7fffffe07fffffeL & l) != 0L && kind > 57)
                                {
                                    kind = 57;
                                }

                                break;
                            case 8:
                                if (character == 92)
                                {
                                    jjCheckNAddStates(40, 43);
                                }

                                break;
                            case 9:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(9, 10);
                                }

                                break;
                            case 11:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(11, 12);
                                }

                                break;
                            case 13:
                                if (character == 92)
                                {
                                    jjAddStates(46, 47);
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (character >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (character & 0xff) >> 6;
                    long l2 = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 16 - (jjnewStateCnt = startsAt)))
                {
                    return curPos;
                }

                if (!input_stream.ReadChar())
                {
                    return curPos;
                }
            }
        }

        private int jjStopStringLiteralDfa_1(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0xd000L) != 0L)
                    {
                        return 2;
                    }

                    if ((active0 & 0x6000000L) != 0L)
                    {
                        jjmatchedKind = 56;
                        return 25;
                    }
                    if ((active0 & 0x10L) != 0L)
                    {
                        return 27;
                    }

                    return -1;
                case 1:
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return 0;
                    }

                    if ((active0 & 0x6000000L) != 0L)
                    {
                        jjmatchedKind = 56;
                        jjmatchedPos = 1;
                        return 25;
                    }
                    return -1;
                case 2:
                    if ((active0 & 0x6000000L) != 0L)
                    {
                        jjmatchedKind = 56;
                        jjmatchedPos = 2;
                        return 25;
                    }
                    return -1;
                case 3:
                    if ((active0 & 0x4000000L) != 0L)
                    {
                        jjmatchedKind = 56;
                        jjmatchedPos = 3;
                        return 25;
                    }
                    if ((active0 & 0x2000000L) != 0L)
                    {
                        return 25;
                    }

                    return -1;
                default:
                    return -1;
            }
        }

        private int jjStartNfa_1(int pos, long active0)
        {
            return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
        }

        private int jjStartNfaWithStates_1(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            if (!input_stream.ReadChar())
            {
                return pos + 1;
            }
            return jjMoveNfa_1(state, pos + 1);
        }

        private int jjMoveStringLiteralDfa0_1()
        {
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    jjmatchedKind = 15;
                    return jjMoveStringLiteralDfa1_1(0x5000L);
                case (char)41:
                    return jjStopAtPos(0, 7);
                case (char)44:
                    return jjStopAtPos(0, 3);
                case (char)46:
                    return jjMoveStringLiteralDfa1_1(0x10L);
                case (char)91:
                    return jjStopAtPos(0, 1);
                case (char)93:
                    return jjStopAtPos(0, 2);
                case (char)102:
                    return jjMoveStringLiteralDfa1_1(0x4000000L);
                case (char)116:
                    return jjMoveStringLiteralDfa1_1(0x2000000L);
                case (char)123:
                    return jjStopAtPos(0, 58);
                case (char)125:
                    return jjStopAtPos(0, 59);
                default:
                    return jjMoveNfa_1(3, 0);
            }
        }

        private int jjMoveStringLiteralDfa1_1(long active0)
        {
            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_1(0, active0);
                return 1;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    if ((active0 & 0x1000L) != 0L)
                    {
                        return jjStopAtPos(1, 12);
                    }

                    break;
                case (char)42:
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return jjStartNfaWithStates_1(1, 14, 0);
                    }

                    break;
                case (char)46:
                    if ((active0 & 0x10L) != 0L)
                    {
                        return jjStopAtPos(1, 4);
                    }

                    break;
                case (char)97:
                    return jjMoveStringLiteralDfa2_1(active0, 0x4000000L);
                case (char)114:
                    return jjMoveStringLiteralDfa2_1(active0, 0x2000000L);
                default:
                    break;
            }
            return jjStartNfa_1(0, active0);
        }

        private int jjMoveStringLiteralDfa2_1(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_1(0, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_1(1, active0);
                return 2;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)108:
                    return jjMoveStringLiteralDfa3_1(active0, 0x4000000L);
                case (char)117:
                    return jjMoveStringLiteralDfa3_1(active0, 0x2000000L);
                default:
                    break;
            }
            return jjStartNfa_1(1, active0);
        }

        private int jjMoveStringLiteralDfa3_1(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_1(1, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_1(2, active0);
                return 3;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)101:
                    if ((active0 & 0x2000000L) != 0L)
                    {
                        return jjStartNfaWithStates_1(3, 25, 25);
                    }

                    break;
                case (char)115:
                    return jjMoveStringLiteralDfa4_1(active0, 0x4000000L);
                default:
                    break;
            }
            return jjStartNfa_1(2, active0);
        }

        private int jjMoveStringLiteralDfa4_1(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_1(2, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_1(3, active0);
                return 4;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)101:
                    if ((active0 & 0x4000000L) != 0L)
                    {
                        return jjStartNfaWithStates_1(4, 26, 25);
                    }

                    break;
                default:
                    break;
            }
            return jjStartNfa_1(3, active0);
        }

        private int jjMoveNfa_1(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 36;
            int i = 1;
            jjstateSet[0] = (uint)startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                {
                    ReInitRounds();
                }

                char character = input_stream.CurrentCharacter;
                if (character < 64)
                {
                    long l = 1L << character;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if ((0x3ff000000000000L & l) != 0L)
                                {
                                    if (kind > 49)
                                    {
                                        kind = 49;
                                    }

                                    jjCheckNAdd(23);
                                }
                                else if ((0x100000200L & l) != 0L)
                                {
                                    if (kind > 23)
                                    {
                                        kind = 23;
                                    }

                                    jjCheckNAdd(4);
                                }
                                else if (character == 36)
                                {
                                    if (kind > 10)
                                    {
                                        kind = 10;
                                    }

                                    jjCheckNAddTwoStates(33, 34);
                                }
                                else if (character == 46)
                                {
                                    jjstateSet[jjnewStateCnt++] = 27;
                                }
                                else if (character == 45)
                                {
                                    jjCheckNAdd(23);
                                }
                                else if (character == 39)
                                {
                                    jjCheckNAddStates(62, 64);
                                }
                                else if (character == 34)
                                {
                                    jjCheckNAddStates(65, 67);
                                }
                                else if (character == 35)
                                {
                                    jjstateSet[jjnewStateCnt++] = 2;
                                }

                                break;
                            case 0:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 1;
                                }

                                break;
                            case 1:
                                if ((0xfffffff7ffffffffUL & (ulong)l) != 0L && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 2:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 0;
                                }

                                break;
                            case 4:
                                if ((0x100000200L & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 23)
                                {
                                    kind = 23;
                                }

                                jjCheckNAdd(4);
                                break;
                            case 5:
                                if (character == 34)
                                {
                                    jjCheckNAddStates(65, 67);
                                }

                                break;
                            case 6:
                                if ((0xfffffffbffffdbffUL & (ulong)l) != 0L)
                                {
                                    jjCheckNAddStates(65, 67);
                                }

                                break;
                            case 7:
                                if (character == 34 && kind > 24)
                                {
                                    kind = 24;
                                }

                                break;
                            case 9:
                                if ((0x8400000000L & l) != 0L)
                                {
                                    jjCheckNAddStates(65, 67);
                                }

                                break;
                            case 10:
                                if ((0xff000000000000L & l) != 0L)
                                {
                                    jjCheckNAddStates(68, 71);
                                }

                                break;
                            case 11:
                                if ((0xff000000000000L & l) != 0L)
                                {
                                    jjCheckNAddStates(65, 67);
                                }

                                break;
                            case 12:
                                if ((0xf000000000000L & l) != 0L)
                                {
                                    jjstateSet[jjnewStateCnt++] = 13;
                                }

                                break;
                            case 13:
                                if ((0xff000000000000L & l) != 0L)
                                {
                                    jjCheckNAdd(11);
                                }

                                break;
                            case 14:
                                if (character == 32)
                                {
                                    jjAddStates(72, 73);
                                }

                                break;
                            case 15:
                                if (character == 10)
                                {
                                    jjCheckNAddStates(65, 67);
                                }

                                break;
                            case 16:
                                if (character == 39)
                                {
                                    jjCheckNAddStates(62, 64);
                                }

                                break;
                            case 17:
                                if ((0xffffff7fffffdbffUL & (ulong)l) != 0L)
                                {
                                    jjCheckNAddStates(62, 64);
                                }

                                break;
                            case 19:
                                if (character == 32)
                                {
                                    jjAddStates(13, 14);
                                }

                                break;
                            case 20:
                                if (character == 10)
                                {
                                    jjCheckNAddStates(62, 64);
                                }

                                break;
                            case 21:
                                if (character == 39 && kind > 24)
                                {
                                    kind = 24;
                                }

                                break;
                            case 22:
                                if (character == 45)
                                {
                                    jjCheckNAdd(23);
                                }

                                break;
                            case 23:
                                if ((0x3ff000000000000L & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 49)
                                {
                                    kind = 49;
                                }

                                jjCheckNAdd(23);
                                break;
                            case 25:
                                if ((0x3ff200000000000L & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 56)
                                {
                                    kind = 56;
                                }

                                jjstateSet[jjnewStateCnt++] = 25;
                                break;
                            case 26:
                                if (character == 46)
                                {
                                    jjstateSet[jjnewStateCnt++] = 27;
                                }

                                break;
                            case 30:
                                if (character == 36 && kind > 10)
                                {
                                    kind = 10;
                                }

                                break;
                            case 32:
                                if (character == 36)
                                {
                                    jjCheckNAddTwoStates(33, 34);
                                }

                                break;
                            case 34:
                                if (character == 33 && kind > 11)
                                {
                                    kind = 11;
                                }

                                break;
                            case 35:
                                if (character != 36)
                                {
                                    break;
                                }

                                if (kind > 10)
                                {
                                    kind = 10;
                                }

                                jjCheckNAddTwoStates(33, 34);
                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else if (character < 128)
                {
                    long l = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if ((0x7fffffe87fffffeL & l) != 0L)
                                {
                                    if (kind > 56)
                                    {
                                        kind = 56;
                                    }

                                    jjCheckNAdd(25);
                                }
                                else if (character == 92)
                                {
                                    jjCheckNAddStates(74, 77);
                                }

                                break;
                            case 1:
                                if (kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 6:
                                if ((0xffffffffefffffffUL & (ulong)l) != 0L)
                                {
                                    jjCheckNAddStates(65, 67);
                                }

                                break;
                            case 8:
                                if (character == 92)
                                {
                                    jjAddStates(78, 82);
                                }

                                break;
                            case 9:
                                if ((0x14404410000000L & l) != 0L)
                                {
                                    jjCheckNAddStates(65, 67);
                                }

                                break;
                            case 17:
                                jjAddStates(62, 64);
                                break;
                            case 18:
                                if (character == 92)
                                {
                                    jjAddStates(13, 14);
                                }

                                break;
                            case 24:
                            case 25:
                                if ((0x7fffffe87fffffeL & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 56)
                                {
                                    kind = 56;
                                }

                                jjCheckNAdd(25);
                                break;
                            case 27:
                                if ((0x7fffffe07fffffeL & l) != 0L && kind > 57)
                                {
                                    kind = 57;
                                }

                                break;
                            case 28:
                                if (character == 92)
                                {
                                    jjCheckNAddStates(74, 77);
                                }

                                break;
                            case 29:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(29, 30);
                                }

                                break;
                            case 31:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(31, 32);
                                }

                                break;
                            case 33:
                                if (character == 92)
                                {
                                    jjAddStates(83, 84);
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = (character >> 8);
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (character & 0xff) >> 6;
                    long l2 = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 6:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                                {
                                    jjAddStates(65, 67);
                                }

                                break;
                            case 17:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                                {
                                    jjAddStates(62, 64);
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 36 - (jjnewStateCnt = startsAt)))
                {
                    return curPos;
                }

                if (!input_stream.ReadChar())
                {
                    return curPos;
                }
            }
        }

        private int jjStopStringLiteralDfa_2(int pos, long active0)
        {
            switch (pos)
            {
                case 0:
                    if ((active0 & 0xd000L) != 0L)
                    {
                        return 2;
                    }

                    if ((active0 & 0x6000000L) != 0L)
                    {
                        jjmatchedKind = 56;
                        return 5;
                    }
                    return -1;
                case 1:
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return 0;
                    }

                    if ((active0 & 0x6000000L) != 0L)
                    {
                        jjmatchedKind = 56;
                        jjmatchedPos = 1;
                        return 5;
                    }
                    return -1;
                case 2:
                    if ((active0 & 0x6000000L) != 0L)
                    {
                        jjmatchedKind = 56;
                        jjmatchedPos = 2;
                        return 5;
                    }
                    return -1;
                case 3:
                    if ((active0 & 0x4000000L) != 0L)
                    {
                        jjmatchedKind = 56;
                        jjmatchedPos = 3;
                        return 5;
                    }
                    if ((active0 & 0x2000000L) != 0L)
                    {
                        return 5;
                    }

                    return -1;
                default:
                    return -1;
            }
        }

        private int jjStartNfa_2(int pos, long active0)
        {
            return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
        }

        private int jjStartNfaWithStates_2(int pos, int kind, int state)
        {
            jjmatchedKind = kind;
            jjmatchedPos = pos;
            if (!input_stream.ReadChar())
            {
                return pos + 1;
            }
            return jjMoveNfa_2(state, pos + 1);
        }

        private int jjMoveStringLiteralDfa0_2()
        {
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    jjmatchedKind = 15;
                    return jjMoveStringLiteralDfa1_2(0x5000L);
                case (char)40:
                    return jjStopAtPos(0, 5);
                case (char)102:
                    return jjMoveStringLiteralDfa1_2(0x4000000L);
                case (char)116:
                    return jjMoveStringLiteralDfa1_2(0x2000000L);
                case (char)123:
                    return jjStopAtPos(0, 58);
                case (char)125:
                    return jjStopAtPos(0, 59);
                default:
                    return jjMoveNfa_2(3, 0);
            }
        }

        private int jjMoveStringLiteralDfa1_2(long active0)
        {
            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_2(0, active0);
                return 1;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)35:
                    if ((active0 & 0x1000L) != 0L)
                    {
                        return jjStopAtPos(1, 12);
                    }

                    break;
                case (char)42:
                    if ((active0 & 0x4000L) != 0L)
                    {
                        return jjStartNfaWithStates_2(1, 14, 0);
                    }

                    break;
                case (char)97:
                    return jjMoveStringLiteralDfa2_2(active0, 0x4000000L);
                case (char)114:
                    return jjMoveStringLiteralDfa2_2(active0, 0x2000000L);
                default:
                    break;
            }
            return jjStartNfa_2(0, active0);
        }

        private int jjMoveStringLiteralDfa2_2(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_2(0, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_2(1, active0);
                return 2;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)108:
                    return jjMoveStringLiteralDfa3_2(active0, 0x4000000L);
                case (char)117:
                    return jjMoveStringLiteralDfa3_2(active0, 0x2000000L);
                default:
                    break;
            }
            return jjStartNfa_2(1, active0);
        }

        private int jjMoveStringLiteralDfa3_2(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_2(1, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_2(2, active0);
                return 3;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)101:
                    if ((active0 & 0x2000000L) != 0L)
                    {
                        return jjStartNfaWithStates_2(3, 25, 5);
                    }

                    break;
                case (char)115:
                    return jjMoveStringLiteralDfa4_2(active0, 0x4000000L);
                default:
                    break;
            }
            return jjStartNfa_2(2, active0);
        }

        private int jjMoveStringLiteralDfa4_2(long old0, long active0)
        {
            if (((active0 &= old0)) == 0L)
            {
                return jjStartNfa_2(2, old0);
            }

            if (!input_stream.ReadChar())
            {
                jjStopStringLiteralDfa_2(3, active0);
                return 4;
            }
            switch (input_stream.CurrentCharacter)
            {
                case (char)101:
                    if ((active0 & 0x4000000L) != 0L)
                    {
                        return jjStartNfaWithStates_2(4, 26, 5);
                    }

                    break;
                default:
                    break;
            }
            return jjStartNfa_2(3, active0);
        }

        private int jjMoveNfa_2(int startState, int curPos)
        {
            int startsAt = 0;
            jjnewStateCnt = 16;
            int i = 1;
            jjstateSet[0] = (uint)startState;
            int kind = 0x7fffffff;
            for (; ; )
            {
                if (++jjround == 0x7fffffff)
                {
                    ReInitRounds();
                }

                char character = input_stream.CurrentCharacter;
                if (character < 64)
                {
                    long l = 1L << character;
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if (character == 36)
                                {
                                    if (kind > 10)
                                    {
                                        kind = 10;
                                    }

                                    jjCheckNAddTwoStates(13, 14);
                                }
                                else if (character == 46)
                                {
                                    jjstateSet[jjnewStateCnt++] = 7;
                                }
                                else if (character == 35)
                                {
                                    jjstateSet[jjnewStateCnt++] = 2;
                                }

                                break;
                            case 0:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 1;
                                }

                                break;
                            case 1:
                                if ((0xfffffff7ffffffffUL & (ulong)l) != 0L && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 2:
                                if (character == 42)
                                {
                                    jjstateSet[jjnewStateCnt++] = 0;
                                }

                                break;
                            case 5:
                                if ((0x3ff200000000000L & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 56)
                                {
                                    kind = 56;
                                }

                                jjstateSet[jjnewStateCnt++] = 5;
                                break;
                            case 6:
                                if (character == 46)
                                {
                                    jjstateSet[jjnewStateCnt++] = 7;
                                }

                                break;
                            case 10:
                                if (character == 36 && kind > 10)
                                {
                                    kind = 10;
                                }

                                break;
                            case 12:
                                if (character == 36)
                                {
                                    jjCheckNAddTwoStates(13, 14);
                                }

                                break;
                            case 14:
                                if (character == 33 && kind > 11)
                                {
                                    kind = 11;
                                }

                                break;
                            case 15:
                                if (character != 36)
                                {
                                    break;
                                }

                                if (kind > 10)
                                {
                                    kind = 10;
                                }

                                jjCheckNAddTwoStates(13, 14);
                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else if (character < 128)
                {
                    long l = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 3:
                                if ((0x7fffffe87fffffeL & l) != 0L)
                                {
                                    if (kind > 56)
                                    {
                                        kind = 56;
                                    }

                                    jjCheckNAdd(5);
                                }
                                else if (character == 92)
                                {
                                    jjCheckNAddStates(40, 43);
                                }

                                break;
                            case 1:
                                if (kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            case 4:
                            case 5:
                                if ((0x7fffffe87fffffeL & l) == 0L)
                                {
                                    break;
                                }

                                if (kind > 56)
                                {
                                    kind = 56;
                                }

                                jjCheckNAdd(5);
                                break;
                            case 7:
                                if ((0x7fffffe07fffffeL & l) != 0L && kind > 57)
                                {
                                    kind = 57;
                                }

                                break;
                            case 8:
                                if (character == 92)
                                {
                                    jjCheckNAddStates(40, 43);
                                }

                                break;
                            case 9:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(9, 10);
                                }

                                break;
                            case 11:
                                if (character == 92)
                                {
                                    jjCheckNAddTwoStates(11, 12);
                                }

                                break;
                            case 13:
                                if (character == 92)
                                {
                                    jjAddStates(46, 47);
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                else
                {
                    int hiByte = character >> 8;
                    int i1 = hiByte >> 6;
                    long l1 = 1L << (hiByte & 63);
                    int i2 = (character & 0xff) >> 6;
                    long l2 = 1L << (character & 63);
                    do
                    {
                        switch (jjstateSet[--i])
                        {
                            case 1:
                                if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
                                {
                                    kind = 13;
                                }

                                break;
                            default:
                                break;
                        }
                    } while (i != startsAt);
                }
                if (kind != 0x7fffffff)
                {
                    jjmatchedKind = kind;
                    jjmatchedPos = curPos;
                    kind = 0x7fffffff;
                }
                ++curPos;
                if ((i = jjnewStateCnt) == (startsAt = 16 - (jjnewStateCnt = startsAt)))
                {
                    return curPos;
                }

                if (!input_stream.ReadChar())
                {
                    return curPos;
                }
            }
        }

        private static readonly int[] jjnextStates = {
                                                22, 23, 26, 11, 12, 13, 1, 2, 4, 11, 16, 12, 13, 19, 20, 24,
                                                25, 35, 36, 37, 38, 14, 15, 17, 19, 20, 39, 40, 5, 6, 7, 8,
                                                9, 10, 24, 25, 27, 18, 19, 21, 9, 10, 11, 12, 22, 29, 13, 14,
                                                7, 8, 16, 17, 18, 19, 20, 21, 8, 9, 10, 11, 12, 13, 17, 18,
                                                21, 6, 7, 8, 6, 11, 7, 8, 14, 15, 29, 30, 31, 32, 9, 10,
                                                12, 14, 15, 33, 34,
                                            };

        private static bool jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
        {
            switch (hiByte)
            {
                case 0:
                    return ((jjbitVec2[i2] & (ulong)l2) != 0L);
                default:
                    if ((jjbitVec0[i1] & (ulong)l1) != 0L)
                    {
                        return true;
                    }

                    return false;
            }
        }

        public static string[] jjstrLiteralImages = {
                                                        null, null, null, null, null, null, null, null, null, null, null, null,
                                                        null,
                                                        null, null, null, null, null, null, null, null, null, null, null, null,
                                                        null, null,
                                                        null, null, null, null, null, null, null, null, null, null, null, null,
                                                        null, null,
                                                        null, null, null, null, null, null, null, null, null, null, null, null,
                                                        null, null,
                                                        null, null, null, null, null, null, null,
                                                    };

        public static string[] lexStateNames = {
                                                   "DIRECTIVE",
                                                   "REFMOD2",
                                                   "REFMODIFIER",
                                                   "DEFAULT",
                                                   "PRE_DIRECTIVE",
                                                   "REFERENCE",
                                                   "IN_MULTI_LINE_COMMENT",
                                                   "IN_FORMAL_COMMENT",
                                                   "IN_SINGLE_LINE_COMMENT",
                                               };

        public static int[] jjnewLexState = {
                                                -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                                                -1, -1, -1, -1, -1,
                                                -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                                                -1, -1, -1, -1, -1,
                                                -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                                            };

        private static readonly long[] jjtoToken = {
                                              0xf12ffffffbf03ffL,
                                          };

        private static readonly long[] jjtoSkip = {
                                             0x3000000000000000L,
                                         };

        private static readonly long[] jjtoSpecial = {
                                                0x3000000000000000L,
                                            };

        private ICharStream input_stream;
        private readonly uint[] jjrounds = new uint[42];
        private readonly uint[] jjstateSet = new uint[84];
        private StringBuilder image;
        private int jjimageLen;

        public ParserTokenManager(ICharStream stream)
        {
            input_stream = stream;
        }

        public ParserTokenManager(ICharStream stream, int lexState) : this(stream)
        {
            SwitchTo(lexState);
        }

        public void ReInit(ICharStream stream)
        {
            jjmatchedPos = jjnewStateCnt = 0;
            curLexState = defaultLexState;
            input_stream = stream;
            ReInitRounds();
        }

        private void ReInitRounds()
        {
            int i;
            jjround = 0x80000001;
            for (i = 42; i-- > 0;)
            {
                jjrounds[i] = 0x80000000;
            }
        }

        public void ReInit(ICharStream stream, int lexState)
        {
            ReInit(stream);
            SwitchTo(lexState);
        }

        public void SwitchTo(int lexState)
        {
            if (lexState >= 9 || lexState < 0)
            {
                throw new TokenMgrError(string.Format("Error: Ignoring invalid lexical state : {0}. State unchanged.", lexState),
                                        TokenMgrError.INVALID_LEXICAL_STATE);
            }
            else
            {
                curLexState = lexState;
            }
        }

        private Token jjFillToken()
        {
            Token t = Token.NewToken(jjmatchedKind);
            t.Kind = jjmatchedKind;
            string im = jjstrLiteralImages[jjmatchedKind];
            t.Image = (im == null) ? input_stream.GetImage() : im;
            t.BeginLine = input_stream.BeginLine;
            t.BeginColumn = input_stream.BeginColumn;
            t.EndLine = input_stream.EndLine;
            t.EndColumn = input_stream.EndColumn;
            return t;
        }

        private int curLexState = 3;
        private readonly int defaultLexState = 3;
        private int jjnewStateCnt;
        private uint jjround;
        private int jjmatchedPos;
        private int jjmatchedKind;

        public Token NextToken
        {
            get
            {
                Token specialToken = null;
                Token matchedToken;
                int curPos = 0;

                for (; ; )
                {
                    if (!input_stream.BeginToken())
                    {
                        jjmatchedKind = 0;
                        matchedToken = jjFillToken();
                        matchedToken.SpecialToken = specialToken;
                        return matchedToken;
                    }
                    image = null;
                    jjimageLen = 0;

                    for (; ; )
                    {
                        switch (curLexState)
                        {
                            case 0:
                                jjmatchedKind = 0x7fffffff;
                                jjmatchedPos = 0;
                                curPos = jjMoveStringLiteralDfa0_0();
                                break;
                            case 1:
                                jjmatchedKind = 0x7fffffff;
                                jjmatchedPos = 0;
                                curPos = jjMoveStringLiteralDfa0_1();
                                if (jjmatchedPos == 0 && jjmatchedKind > 60)
                                {
                                    jjmatchedKind = 60;
                                }
                                break;
                            case 2:
                                jjmatchedKind = 0x7fffffff;
                                jjmatchedPos = 0;
                                curPos = jjMoveStringLiteralDfa0_2();
                                if (jjmatchedPos == 0 && jjmatchedKind > 60)
                                {
                                    jjmatchedKind = 60;
                                }
                                break;
                            case 3:
                                jjmatchedKind = 0x7fffffff;
                                jjmatchedPos = 0;
                                curPos = jjMoveStringLiteralDfa0_3();
                                break;
                            case 4:
                                jjmatchedKind = 0x7fffffff;
                                jjmatchedPos = 0;
                                curPos = jjMoveStringLiteralDfa0_4();
                                if (jjmatchedPos == 0 && jjmatchedKind > 61)
                                {
                                    jjmatchedKind = 61;
                                }
                                break;
                            case 5:
                                jjmatchedKind = 0x7fffffff;
                                jjmatchedPos = 0;
                                curPos = jjMoveStringLiteralDfa0_5();
                                if (jjmatchedPos == 0 && jjmatchedKind > 60)
                                {
                                    jjmatchedKind = 60;
                                }
                                break;
                            case 6:
                                jjmatchedKind = 0x7fffffff;
                                jjmatchedPos = 0;
                                curPos = jjMoveStringLiteralDfa0_6();
                                if (jjmatchedPos == 0 && jjmatchedKind > 22)
                                {
                                    jjmatchedKind = 22;
                                }
                                break;
                            case 7:
                                jjmatchedKind = 0x7fffffff;
                                jjmatchedPos = 0;
                                curPos = jjMoveStringLiteralDfa0_7();
                                if (jjmatchedPos == 0 && jjmatchedKind > 22)
                                {
                                    jjmatchedKind = 22;
                                }
                                break;
                            case 8:
                                jjmatchedKind = 0x7fffffff;
                                jjmatchedPos = 0;
                                curPos = jjMoveStringLiteralDfa0_8();
                                if (jjmatchedPos == 0 && jjmatchedKind > 22)
                                {
                                    jjmatchedKind = 22;
                                }
                                break;
                        }
                        if (jjmatchedKind != 0x7fffffff)
                        {
                            if (jjmatchedPos + 1 < curPos)
                            {
                                input_stream.Backup(curPos - jjmatchedPos - 1);
                            }

                            if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 63))) != 0L)
                            {
                                matchedToken = jjFillToken();
                                matchedToken.SpecialToken = specialToken;
                                TokenLexicalActions(matchedToken);
                                if (jjnewLexState[jjmatchedKind] != -1)
                                {
                                    curLexState = jjnewLexState[jjmatchedKind];
                                }

                                return matchedToken;
                            }
                            else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 63))) != 0L)
                            {
                                if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 63))) != 0L)
                                {
                                    matchedToken = jjFillToken();
                                    if (specialToken == null)
                                    {
                                        specialToken = matchedToken;
                                    }
                                    else
                                    {
                                        matchedToken.SpecialToken = specialToken;
                                        specialToken = (specialToken.Next = matchedToken);
                                    }
                                    SkipLexicalActions();
                                }
                                else
                                {
                                    SkipLexicalActions();
                                }

                                if (jjnewLexState[jjmatchedKind] != -1)
                                {
                                    curLexState = jjnewLexState[jjmatchedKind];
                                }

                                goto EOFLoop_GOTO;
                            }
                            MoreLexicalActions();
                            if (jjnewLexState[jjmatchedKind] != -1)
                            {
                                curLexState = jjnewLexState[jjmatchedKind];
                            }

                            curPos = 0;
                            jjmatchedKind = 0x7fffffff;

                            if (input_stream.ReadChar())
                            {
                                continue;
                            }
                        }
                        int error_line = input_stream.EndLine;
                        int error_column = input_stream.EndColumn;
                        string error_after = null;
                        bool EOFSeen = false;
                        if (input_stream.ReadChar())
                        {
                            input_stream.Backup(1);
                        }
                        else
                        {
                            EOFSeen = true;
                            error_after = curPos <= 1 ? string.Empty : input_stream.GetImage();
                            char character = input_stream.CurrentCharacter;
                            if (character == '\n' || character == '\r')
                            {
                                error_line++;
                                error_column = 0;
                            }
                            else
                            {
                                error_column++;
                            }
                        }
                        if (!EOFSeen)
                        {
                            input_stream.Backup(1);
                            error_after = curPos <= 1 ? string.Empty : input_stream.GetImage();
                        }
                        throw new TokenMgrError(EOFSeen, error_line, error_column, error_after, input_stream.CurrentCharacter,
                                                TokenMgrError.LEXICAL_ERROR);
                    }
                EOFLoop_GOTO:
                    ;
                }
            }
        }

        private void SkipLexicalActions()
        {
            switch (jjmatchedKind)
            {
                case 60:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }
                    /*
* push every terminator character back into the stream  
*/

                    input_stream.Backup(1);

                    if (debugPrint)
                    {
                        Console.Out.Write("REF_TERM :");
                    }

                    StateStackPop();
                    break;
                case 61:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    if (debugPrint)
                    {
                        Console.Out.Write("DIRECTIVE_TERM :");
                    }

                    input_stream.Backup(1);
                    inDirective = false;
                    StateStackPop();
                    break;
                default:
                    break;
            }
        }

        private void MoreLexicalActions()
        {
            jjimageLen += (jjmatchedPos + 1);
            switch (jjmatchedKind)
            {
                case 10:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen)));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen));
                    }

                    jjimageLen = 0;
                    if (!inComment)
                    {
                        /*
			* if we find ourselves in REFERENCE, we need to pop down
			* to end the previous ref
			*/

                        if (curLexState == REFERENCE)
                        {
                            StateStackPop();
                        }

                        if (debugPrint)
                        {
                            Console.Out.Write("$  : going to {0}", REFERENCE);
                        }

                        StateStackPush();
                        SwitchTo(REFERENCE);
                    }
                    break;
                case 11:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen)));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen));
                    }

                    jjimageLen = 0;
                    if (!inComment)
                    {
                        /*
			* if we find ourselves in REFERENCE, we need to pop down
			* to end the previous ref
			*/

                        if (curLexState == REFERENCE)
                        {
                            StateStackPop();
                        }

                        if (debugPrint)
                        {
                            Console.Out.Write("$!  : going to {0}", REFERENCE);
                        }

                        StateStackPush();
                        SwitchTo(REFERENCE);
                    }
                    break;
                case 12:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen)));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen));
                    }

                    jjimageLen = 0;
                    if (!inComment)
                    {
                        if (curLexState == REFERENCE)
                        {
                            StateStackPop();
                        }

                        inComment = true;
                        StateStackPush();
                        SwitchTo(IN_SINGLE_LINE_COMMENT);
                    }
                    break;
                case 13:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen)));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen));
                    }

                    jjimageLen = 0;
                    input_stream.Backup(1);
                    inComment = true;
                    StateStackPush();
                    SwitchTo(IN_FORMAL_COMMENT);
                    break;
                case 14:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen)));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen));
                    }

                    jjimageLen = 0;
                    inComment = true;
                    StateStackPush();
                    SwitchTo(IN_MULTI_LINE_COMMENT);
                    break;
                case 15:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen)));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen));
                    }

                    jjimageLen = 0;
                    if (!inComment)
                    {
                        /*
			* We can have the situation where #if($foo)$foo#end.  
			* We need to transition out of REFERENCE before going to DIRECTIVE. 
			* I don't really like this, but I can't think of a legal way 
			* you are going into DIRECTIVE while in REFERENCE.  -gmj
			*/

                        if (curLexState == REFERENCE || curLexState == REFMODIFIER)
                        {
                            StateStackPop();
                        }

                        inDirective = true;

                        if (debugPrint)
                        {
                            Console.Out.Write("# :  going to {0}", DIRECTIVE);
                        }

                        StateStackPush();
                        SwitchTo(PRE_DIRECTIVE);
                    }
                    break;
                default:
                    break;
            }
        }

        private void TokenLexicalActions(Token matchedToken)
        {
            switch (jjmatchedKind)
            {
                case 5:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    if (!inComment)
                    {
                        lparen++;
                    }

                    /*
		    * If in REFERENCE and we have seen the dot, then move 
		    * to REFMOD2 -> Modifier()
		    */

                    if (curLexState == REFMODIFIER)
                    {
                        SwitchTo(REFMOD2);
                    }

                    break;
                case 6:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    RPARENHandler();
                    break;
                case 7:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }
                    /*
* need to simply switch back to REFERENCE, not drop down the stack
* because we can (infinitely) chain, ala 
* $foo.bar().blargh().woogie().doogie()
*/

                    SwitchTo(REFERENCE);
                    break;
                case 9:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    if (!inComment)
                    {
                        inDirective = true;

                        if (debugPrint)
                        {
                            Console.Out.Write("#set :  going to {0}", DIRECTIVE);
                        }

                        StateStackPush();
                        inSet = true;
                        SwitchTo(DIRECTIVE);
                    }
                    break;
                case 19:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    inComment = false;
                    StateStackPop();
                    break;
                case 20:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    inComment = false;
                    StateStackPop();
                    break;
                case 21:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    inComment = false;
                    StateStackPop();
                    break;
                case 24:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }
                    /*
*  - if we are in DIRECTIVE and haven't seen ( yet, then also drop out. 
*      don't forget to account for the beloved yet wierd #set
*  - finally, if we are in REFMOD2 (remember : $foo.bar( ) then " is ok!
*/

                    if (curLexState == DIRECTIVE && !inSet && lparen == 0)
                    {
                        StateStackPop();
                    }

                    break;
                case 27:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    if (debugPrint)
                    {
                        Console.Out.WriteLine(" NEWLINE :");
                    }

                    StateStackPop();

                    if (inSet)
                    {
                        inSet = false;
                    }

                    if (inDirective)
                    {
                        inDirective = false;
                    }

                    break;
                case 43:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    inDirective = false;
                    StateStackPop();
                    break;
                case 44:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    SwitchTo(DIRECTIVE);
                    break;
                case 45:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    SwitchTo(DIRECTIVE);
                    break;
                case 46:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    inDirective = false;
                    StateStackPop();
                    break;
                case 47:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    matchedToken.Kind = EOF;
                    break;
                case 49:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }
                    /*
* check to see if we are in set
*    ex.  #set $foo = $foo + 3
*  because we want to handle the \n after
*/

                    if (lparen == 0 && !inSet && curLexState != REFMOD2)
                    {
                        StateStackPop();
                    }
                    break;
                case 57:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }
                    /*
* push the alpha char back into the stream so the following identifier 
* is complete
*/

                    input_stream.Backup(1);

                    /*
		    * and munge the <DOT> so we just get a . when we have normal text that 
		    * looks like a ref.ident
		    */

                    matchedToken.Image = ".";

                    if (debugPrint)
                    {
                        Console.Out.Write("DOT : switching to {0}", REFMODIFIER);
                    }

                    SwitchTo(REFMODIFIER);
                    break;
                case 59:
                    if (image == null)
                    {
                        image = new StringBuilder(new string(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1))));
                    }
                    else
                    {
                        image.Append(input_stream.GetSuffix(jjimageLen + (jjmatchedPos + 1)));
                    }

                    StateStackPop();
                    break;
                default:
                    break;
            }
        }
    }
}